﻿Imports tokenizer.AST.Stmts
Imports tokenizer.AST.Tokens
Imports dnu
Imports System.Linq
Imports System.Collections.Generic
Imports System.Collections
Imports Microsoft.VisualBasic
Imports System.Xml
Imports System.Xml.Linq
Imports System.Data

Imports System
Imports System.Diagnostics
Imports System.Diagnostics.SymbolStore
Imports System.Reflection
Imports System.Resources
Imports System.Reflection.Emit
Module Module1

Public asmName As AssemblyName
Public asm As AssemblyBuilder
Public Typ As Type
Public Typ02 As Type
Public Typ03 As Type
Public Typ04 As Type
Public impstr(-1) As String
Public impasm(-1) As Assembly
Public interfacebool As Boolean
Public mdl As ModuleBuilder
Public resw As IResourceWriter
Public resobj As Object

Dim doc As ISymbolDocumentWriter

Sub addstr(ByVal str As String)
ReDim Preserve impstr(UBound(impstr) + 1)
impstr(UBound(impstr)) = str
End Sub

Sub addasm(ByVal asm As Assembly)
ReDim Preserve impasm(UBound(impasm) + 1)
impasm(UBound(impasm)) = asm
End Sub

Function MakeGetType(ByVal TypeName As String) As Type
Dim attachbrackets As Boolean = False
If TypeName Like "*[[]*]" Then
Dim split As String() = TypeName.Split(New [Char] () {"[","]"})
TypeName = split(0)
attachbrackets = True
End If
Dim ind As Integer = -1
Dim i As Integer = -1
Dim len As Integer = impstr.Length - 1
Do Until i = len
i = i + 1
If TypeName Like impstr(i) & "*" Then
ind = i
End If
Loop
If ind <> -1 Then
Dim assem As Assembly = impasm(ind)
If attachbrackets = True Then
TypeName = TypeName & "[]"
End If
MakeGetType = assem.GetType(TypeName)
Else
If attachbrackets = True Then
TypeName = TypeName & "[]"
End If
MakeGetType = Type.GetType(TypeName)
End If
Return MakeGetType
End Function

Dim doc2 As ISymbolDocumentWriter

Sub Line()
Dim Line As TypeBuilder = mdl.DefineType("tokenizer.Lexer" & "." & "Line", TypeAttributes.Public Or TypeAttributes.AutoLayout Or TypeAttributes.AnsiClass, GetType(System.Object))
Dim PrevChar As FieldBuilder = Line.DefineField("PrevChar", GetType(System.String), FieldAttributes.Public)
Dim InStr As FieldBuilder = Line.DefineField("InStr", GetType(System.Boolean), FieldAttributes.Public)
Dim InChar As FieldBuilder = Line.DefineField("InChar", GetType(System.Boolean), FieldAttributes.Public)
Dim ctor0 As ConstructorBuilder = Line.DefineConstructor(MethodAttributes.Public,CallingConventions.Standard , Type.EmptyTypes)
Dim ctor0IL As ILGenerator = ctor0.GetILGenerator()
Dim ctor0param00 As ParameterBuilder = ctor0.DefineParameter(0, ParameterAttributes.RetVal, "")
ctor0IL.MarkSequencePoint(doc2, 8, 1, 8, 100)
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Call, GetType(System.Object).GetConstructor(Type.EmptyTypes))
ctor0IL.MarkSequencePoint(doc2, 9, 1, 9, 100)
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
ctor0IL.Emit(OpCodes.Stfld, PrevChar)
ctor0IL.MarkSequencePoint(doc2, 10, 1, 10, 100)
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
ctor0IL.Emit(OpCodes.Stfld, InStr)
ctor0IL.MarkSequencePoint(doc2, 11, 1, 11, 100)
ctor0IL.Emit(OpCodes.Ldarg_0)
ctor0IL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
ctor0IL.Emit(OpCodes.Stfld, InChar)
ctor0IL.MarkSequencePoint(doc2, 12, 1, 12, 100)
ctor0IL.Emit(OpCodes.Ret)
Dim typ0(-1) As Type
ReDim Preserve typ0(UBound(typ0) + 1)
typ0(UBound(typ0)) = GetType(System.String)
ReDim Preserve typ0(UBound(typ0) + 1)
typ0(UBound(typ0)) = GetType(System.String)
ReDim Preserve typ0(UBound(typ0) + 1)
typ0(UBound(typ0)) = GetType(System.Boolean).MakeByRefType()
ReDim Preserve typ0(UBound(typ0) + 1)
typ0(UBound(typ0)) = GetType(System.Boolean).MakeByRefType()
Dim isSep As MethodBuilder = Line.DefineMethod("isSep", MethodAttributes.Public, GetType(System.Boolean), typ0)
Dim isSepIL As ILGenerator = isSep.GetILGenerator()
Dim isSepparam00 As ParameterBuilder = isSep.DefineParameter(0, ParameterAttributes.RetVal, "")
Dim isSepparam01 As ParameterBuilder = isSep.DefineParameter(1, ParameterAttributes.None, "cc")
Dim isSepparam02 As ParameterBuilder = isSep.DefineParameter(2, ParameterAttributes.None, "lc")
Dim isSepparam03 As ParameterBuilder = isSep.DefineParameter(3, ParameterAttributes.None, "sca")
Dim isSepparam04 As ParameterBuilder = isSep.DefineParameter(4, ParameterAttributes.None, "scla")
isSepIL.MarkSequencePoint(doc2, 16, 1, 16, 100)
Dim locbldr0 As LocalBuilder = isSepIL.DeclareLocal(GetType(System.Int32))
locbldr0.SetLocalSymInfo("comp")
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 17, 1, 17, 100)
Dim locbldr1 As LocalBuilder = isSepIL.DeclareLocal(GetType(System.Boolean))
locbldr1.SetLocalSymInfo("orflg")
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 1)
isSepIL.MarkSequencePoint(doc2, 18, 1, 18, 100)
Dim locbldr2 As LocalBuilder = isSepIL.DeclareLocal(GetType(System.Boolean))
locbldr2.SetLocalSymInfo("ob")
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 19, 1, 19, 100)
Dim locbldr3 As LocalBuilder = isSepIL.DeclareLocal(GetType(System.Char))
locbldr3.SetLocalSymInfo("tc")
isSepIL.Emit(OpCodes.Ldstr, "a")
Typ = GetType(System.String)
Dim typ1 As Type() = {Typ}
isSepIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToChar", typ1))
Typ = GetType(System.Convert).GetMethod("ToChar", typ1).ReturnType
isSepIL.Emit(OpCodes.Stloc, 3)
isSepIL.MarkSequencePoint(doc2, 20, 1, 20, 100)
Dim locbldr4 As LocalBuilder = isSepIL.DeclareLocal(GetType(System.Boolean))
locbldr4.SetLocalSymInfo("tb")
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 4)
isSepIL.MarkSequencePoint(doc2, 21, 1, 21, 100)
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
isSepIL.Emit(OpCodes.Ldnull)
Dim fa0 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru0 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont0 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru0)
isSepIL.Emit(OpCodes.Br, fa0)
isSepIL.MarkLabel(tru0)
isSepIL.MarkSequencePoint(doc2, 22, 1, 22, 100)
isSepIL.Emit(OpCodes.Ldstr, " ")
Typ = GetType(System.String)
isSepIL.Emit(OpCodes.Starg, 2)
isSepIL.MarkSequencePoint(doc2, 23, 1, 23, 100)
isSepIL.Emit(OpCodes.Br, cont0)
isSepIL.MarkLabel(fa0)
isSepIL.Emit(OpCodes.Br, cont0)
isSepIL.MarkLabel(cont0)
isSepIL.MarkSequencePoint(doc2, 25, 1, 25, 100)
Dim label0 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.MarkSequencePoint(doc2, 27, 1, 27, 100)
Dim typ2(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ2(UBound(typ2) + 1)
typ2(UBound(typ2)) = Typ
isSepIL.Emit(OpCodes.Ldsfld, GetType(dnu.Constants).GetField("quot"))
Typ = GetType(dnu.Constants).GetField("quot").FieldType
ReDim Preserve typ2(UBound(typ2) + 1)
typ2(UBound(typ2)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ2))
Typ = GetType(String).GetMethod("Compare", typ2).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 28, 1, 28, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa1 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru1 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont1 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru1)
isSepIL.Emit(OpCodes.Br, fa1)
isSepIL.MarkLabel(tru1)
isSepIL.MarkSequencePoint(doc2, 29, 1, 29, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InStr)
Typ = InStr.FieldType
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InStr)
Typ = InStr.FieldType
isSepIL.Emit(OpCodes.And)
isSepIL.Emit(OpCodes.Not)
isSepIL.Emit(OpCodes.Stfld, InStr)
isSepIL.MarkSequencePoint(doc2, 30, 1, 30, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InStr)
Typ = InStr.FieldType
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
Dim fa2 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru2 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont2 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru2)
isSepIL.Emit(OpCodes.Br, fa2)
isSepIL.MarkLabel(tru2)
isSepIL.MarkSequencePoint(doc2, 31, 1, 31, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stfld, InChar)
isSepIL.MarkSequencePoint(doc2, 32, 1, 32, 100)
isSepIL.Emit(OpCodes.Br, cont2)
isSepIL.MarkLabel(fa2)
isSepIL.Emit(OpCodes.Br, cont2)
isSepIL.MarkLabel(cont2)
isSepIL.MarkSequencePoint(doc2, 33, 1, 33, 100)
isSepIL.Emit(OpCodes.Br, cont1)
isSepIL.MarkLabel(fa1)
isSepIL.Emit(OpCodes.Br, cont1)
isSepIL.MarkLabel(cont1)
isSepIL.MarkSequencePoint(doc2, 35, 1, 35, 100)
Dim typ3(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ3(UBound(typ3) + 1)
typ3(UBound(typ3)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "'")
Typ = GetType(System.String)
ReDim Preserve typ3(UBound(typ3) + 1)
typ3(UBound(typ3)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ3))
Typ = GetType(String).GetMethod("Compare", typ3).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 36, 1, 36, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa3 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru3 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont3 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru3)
isSepIL.Emit(OpCodes.Br, fa3)
isSepIL.MarkLabel(tru3)
isSepIL.MarkSequencePoint(doc2, 37, 1, 37, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InChar)
Typ = InChar.FieldType
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InChar)
Typ = InChar.FieldType
isSepIL.Emit(OpCodes.And)
isSepIL.Emit(OpCodes.Not)
isSepIL.Emit(OpCodes.Stfld, InChar)
isSepIL.MarkSequencePoint(doc2, 38, 1, 38, 100)
isSepIL.Emit(OpCodes.Br, cont3)
isSepIL.MarkLabel(fa3)
isSepIL.Emit(OpCodes.Br, cont3)
isSepIL.MarkLabel(cont3)
isSepIL.MarkSequencePoint(doc2, 40, 1, 40, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InStr)
Typ = InStr.FieldType
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, InChar)
Typ = InChar.FieldType
isSepIL.Emit(OpCodes.Or)
isSepIL.Emit(OpCodes.Stloc, 1)
isSepIL.MarkSequencePoint(doc2, 42, 1, 42, 100)
isSepIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
Dim fa4 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru4 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont4 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru4)
isSepIL.Emit(OpCodes.Br, fa4)
isSepIL.MarkLabel(tru4)
isSepIL.MarkSequencePoint(doc2, 44, 1, 44, 100)
Dim typ4(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ4(UBound(typ4) + 1)
typ4(UBound(typ4)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "(")
Typ = GetType(System.String)
ReDim Preserve typ4(UBound(typ4) + 1)
typ4(UBound(typ4)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ4))
Typ = GetType(String).GetMethod("Compare", typ4).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 46, 1, 46, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa5 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru5 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont5 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru5)
isSepIL.Emit(OpCodes.Br, fa5)
isSepIL.MarkLabel(tru5)
isSepIL.MarkSequencePoint(doc2, 47, 1, 47, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 48, 1, 48, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 49, 1, 49, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 50, 1, 50, 100)
isSepIL.Emit(OpCodes.Br, cont5)
isSepIL.MarkLabel(fa5)
isSepIL.Emit(OpCodes.Br, cont5)
isSepIL.MarkLabel(cont5)
isSepIL.MarkSequencePoint(doc2, 52, 1, 52, 100)
Dim typ5(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ5(UBound(typ5) + 1)
typ5(UBound(typ5)) = Typ
isSepIL.Emit(OpCodes.Ldstr, ")")
Typ = GetType(System.String)
ReDim Preserve typ5(UBound(typ5) + 1)
typ5(UBound(typ5)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ5))
Typ = GetType(String).GetMethod("Compare", typ5).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 54, 1, 54, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa6 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru6 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont6 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru6)
isSepIL.Emit(OpCodes.Br, fa6)
isSepIL.MarkLabel(tru6)
isSepIL.MarkSequencePoint(doc2, 55, 1, 55, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 56, 1, 56, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 57, 1, 57, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 58, 1, 58, 100)
isSepIL.Emit(OpCodes.Br, cont6)
isSepIL.MarkLabel(fa6)
isSepIL.Emit(OpCodes.Br, cont6)
isSepIL.MarkLabel(cont6)
isSepIL.MarkSequencePoint(doc2, 60, 1, 60, 100)
Dim typ6(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ6(UBound(typ6) + 1)
typ6(UBound(typ6)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "[")
Typ = GetType(System.String)
ReDim Preserve typ6(UBound(typ6) + 1)
typ6(UBound(typ6)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ6))
Typ = GetType(String).GetMethod("Compare", typ6).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 62, 1, 62, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa7 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru7 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont7 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru7)
isSepIL.Emit(OpCodes.Br, fa7)
isSepIL.MarkLabel(tru7)
isSepIL.MarkSequencePoint(doc2, 63, 1, 63, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 64, 1, 64, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 65, 1, 65, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 66, 1, 66, 100)
isSepIL.Emit(OpCodes.Br, cont7)
isSepIL.MarkLabel(fa7)
isSepIL.Emit(OpCodes.Br, cont7)
isSepIL.MarkLabel(cont7)
isSepIL.MarkSequencePoint(doc2, 68, 1, 68, 100)
Dim typ7(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ7(UBound(typ7) + 1)
typ7(UBound(typ7)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "]")
Typ = GetType(System.String)
ReDim Preserve typ7(UBound(typ7) + 1)
typ7(UBound(typ7)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ7))
Typ = GetType(String).GetMethod("Compare", typ7).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 70, 1, 70, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa8 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru8 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont8 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru8)
isSepIL.Emit(OpCodes.Br, fa8)
isSepIL.MarkLabel(tru8)
isSepIL.MarkSequencePoint(doc2, 71, 1, 71, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 72, 1, 72, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 73, 1, 73, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 74, 1, 74, 100)
isSepIL.Emit(OpCodes.Br, cont8)
isSepIL.MarkLabel(fa8)
isSepIL.Emit(OpCodes.Br, cont8)
isSepIL.MarkLabel(cont8)
isSepIL.MarkSequencePoint(doc2, 76, 1, 76, 100)
Dim typ8(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ8(UBound(typ8) + 1)
typ8(UBound(typ8)) = Typ
isSepIL.Emit(OpCodes.Ldstr, ",")
Typ = GetType(System.String)
ReDim Preserve typ8(UBound(typ8) + 1)
typ8(UBound(typ8)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ8))
Typ = GetType(String).GetMethod("Compare", typ8).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 78, 1, 78, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa9 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru9 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont9 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru9)
isSepIL.Emit(OpCodes.Br, fa9)
isSepIL.MarkLabel(tru9)
isSepIL.MarkSequencePoint(doc2, 79, 1, 79, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 80, 1, 80, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 81, 1, 81, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 82, 1, 82, 100)
isSepIL.Emit(OpCodes.Br, cont9)
isSepIL.MarkLabel(fa9)
isSepIL.Emit(OpCodes.Br, cont9)
isSepIL.MarkLabel(cont9)
isSepIL.MarkSequencePoint(doc2, 84, 1, 84, 100)
Dim typ9(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ9(UBound(typ9) + 1)
typ9(UBound(typ9)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "&")
Typ = GetType(System.String)
ReDim Preserve typ9(UBound(typ9) + 1)
typ9(UBound(typ9)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ9))
Typ = GetType(String).GetMethod("Compare", typ9).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 86, 1, 86, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa10 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru10 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont10 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru10)
isSepIL.Emit(OpCodes.Br, fa10)
isSepIL.MarkLabel(tru10)
isSepIL.MarkSequencePoint(doc2, 87, 1, 87, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 88, 1, 88, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 89, 1, 89, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 90, 1, 90, 100)
isSepIL.Emit(OpCodes.Br, cont10)
isSepIL.MarkLabel(fa10)
isSepIL.Emit(OpCodes.Br, cont10)
isSepIL.MarkLabel(cont10)
isSepIL.MarkSequencePoint(doc2, 92, 1, 92, 100)
Dim typ10(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ10(UBound(typ10) + 1)
typ10(UBound(typ10)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "*")
Typ = GetType(System.String)
ReDim Preserve typ10(UBound(typ10) + 1)
typ10(UBound(typ10)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ10))
Typ = GetType(String).GetMethod("Compare", typ10).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 94, 1, 94, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa11 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru11 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont11 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru11)
isSepIL.Emit(OpCodes.Br, fa11)
isSepIL.MarkLabel(tru11)
isSepIL.MarkSequencePoint(doc2, 95, 1, 95, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 96, 1, 96, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 97, 1, 97, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 98, 1, 98, 100)
isSepIL.Emit(OpCodes.Br, cont11)
isSepIL.MarkLabel(fa11)
isSepIL.Emit(OpCodes.Br, cont11)
isSepIL.MarkLabel(cont11)
isSepIL.MarkSequencePoint(doc2, 100, 1, 100, 100)
Dim typ11(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ11(UBound(typ11) + 1)
typ11(UBound(typ11)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "/")
Typ = GetType(System.String)
ReDim Preserve typ11(UBound(typ11) + 1)
typ11(UBound(typ11)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ11))
Typ = GetType(String).GetMethod("Compare", typ11).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 102, 1, 102, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa12 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru12 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont12 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru12)
isSepIL.Emit(OpCodes.Br, fa12)
isSepIL.MarkLabel(tru12)
isSepIL.MarkSequencePoint(doc2, 103, 1, 103, 100)
Dim typ12(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ12(UBound(typ12) + 1)
typ12(UBound(typ12)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "/")
Typ = GetType(System.String)
ReDim Preserve typ12(UBound(typ12) + 1)
typ12(UBound(typ12)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ12))
Typ = GetType(String).GetMethod("Compare", typ12).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 104, 1, 104, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa13 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru13 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont13 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa13)
isSepIL.Emit(OpCodes.Br, tru13)
isSepIL.MarkLabel(tru13)
isSepIL.MarkSequencePoint(doc2, 105, 1, 105, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 106, 1, 106, 100)
Dim typ13(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ13(UBound(typ13) + 1)
typ13(UBound(typ13)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "/")
Typ = GetType(System.String)
ReDim Preserve typ13(UBound(typ13) + 1)
typ13(UBound(typ13)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ13))
Typ = GetType(String).GetMethod("Compare", typ13).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 107, 1, 107, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa14 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru14 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont14 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru14)
isSepIL.Emit(OpCodes.Br, fa14)
isSepIL.MarkLabel(tru14)
isSepIL.MarkSequencePoint(doc2, 108, 1, 108, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 109, 1, 109, 100)
isSepIL.Emit(OpCodes.Br, cont14)
isSepIL.MarkLabel(fa14)
isSepIL.MarkSequencePoint(doc2, 110, 1, 110, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 111, 1, 111, 100)
isSepIL.Emit(OpCodes.Br, cont14)
isSepIL.MarkLabel(cont14)
isSepIL.MarkSequencePoint(doc2, 112, 1, 112, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 113, 1, 113, 100)
isSepIL.Emit(OpCodes.Br, cont13)
isSepIL.MarkLabel(fa13)
isSepIL.MarkSequencePoint(doc2, 114, 1, 114, 100)
Dim typ14(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ14(UBound(typ14) + 1)
typ14(UBound(typ14)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "/")
Typ = GetType(System.String)
ReDim Preserve typ14(UBound(typ14) + 1)
typ14(UBound(typ14)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ14))
Typ = GetType(String).GetMethod("Compare", typ14).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 115, 1, 115, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa15 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru15 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont15 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru15)
isSepIL.Emit(OpCodes.Br, fa15)
isSepIL.MarkLabel(tru15)
isSepIL.MarkSequencePoint(doc2, 116, 1, 116, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 117, 1, 117, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 118, 1, 118, 100)
isSepIL.Emit(OpCodes.Br, cont15)
isSepIL.MarkLabel(fa15)
isSepIL.MarkSequencePoint(doc2, 119, 1, 119, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 120, 1, 120, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 121, 1, 121, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 122, 1, 122, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 123, 1, 123, 100)
isSepIL.Emit(OpCodes.Br, cont15)
isSepIL.MarkLabel(cont15)
isSepIL.MarkSequencePoint(doc2, 124, 1, 124, 100)
isSepIL.Emit(OpCodes.Br, cont13)
isSepIL.MarkLabel(cont13)
isSepIL.MarkSequencePoint(doc2, 125, 1, 125, 100)
isSepIL.Emit(OpCodes.Br, cont12)
isSepIL.MarkLabel(fa12)
isSepIL.Emit(OpCodes.Br, cont12)
isSepIL.MarkLabel(cont12)
isSepIL.MarkSequencePoint(doc2, 127, 1, 127, 100)
Dim typ15(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ15(UBound(typ15) + 1)
typ15(UBound(typ15)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "|")
Typ = GetType(System.String)
ReDim Preserve typ15(UBound(typ15) + 1)
typ15(UBound(typ15)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ15))
Typ = GetType(String).GetMethod("Compare", typ15).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 129, 1, 129, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa16 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru16 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont16 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru16)
isSepIL.Emit(OpCodes.Br, fa16)
isSepIL.MarkLabel(tru16)
isSepIL.MarkSequencePoint(doc2, 130, 1, 130, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 131, 1, 131, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 132, 1, 132, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 133, 1, 133, 100)
isSepIL.Emit(OpCodes.Br, cont16)
isSepIL.MarkLabel(fa16)
isSepIL.Emit(OpCodes.Br, cont16)
isSepIL.MarkLabel(cont16)
isSepIL.MarkSequencePoint(doc2, 135, 1, 135, 100)
Dim typ16(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ16(UBound(typ16) + 1)
typ16(UBound(typ16)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "$")
Typ = GetType(System.String)
ReDim Preserve typ16(UBound(typ16) + 1)
typ16(UBound(typ16)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ16))
Typ = GetType(String).GetMethod("Compare", typ16).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 137, 1, 137, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa17 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru17 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont17 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru17)
isSepIL.Emit(OpCodes.Br, fa17)
isSepIL.MarkLabel(tru17)
isSepIL.MarkSequencePoint(doc2, 138, 1, 138, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 139, 1, 139, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 140, 1, 140, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 141, 1, 141, 100)
isSepIL.Emit(OpCodes.Br, cont17)
isSepIL.MarkLabel(fa17)
isSepIL.Emit(OpCodes.Br, cont17)
isSepIL.MarkLabel(cont17)
isSepIL.MarkSequencePoint(doc2, 143, 1, 143, 100)
Dim typ17(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ17(UBound(typ17) + 1)
typ17(UBound(typ17)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "~")
Typ = GetType(System.String)
ReDim Preserve typ17(UBound(typ17) + 1)
typ17(UBound(typ17)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ17))
Typ = GetType(String).GetMethod("Compare", typ17).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 145, 1, 145, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa18 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru18 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont18 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru18)
isSepIL.Emit(OpCodes.Br, fa18)
isSepIL.MarkLabel(tru18)
isSepIL.MarkSequencePoint(doc2, 146, 1, 146, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 147, 1, 147, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 148, 1, 148, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 149, 1, 149, 100)
isSepIL.Emit(OpCodes.Br, cont18)
isSepIL.MarkLabel(fa18)
isSepIL.Emit(OpCodes.Br, cont18)
isSepIL.MarkLabel(cont18)
isSepIL.MarkSequencePoint(doc2, 151, 1, 151, 100)
Dim typ18(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ18(UBound(typ18) + 1)
typ18(UBound(typ18)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ18(UBound(typ18) + 1)
typ18(UBound(typ18)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ18))
Typ = GetType(String).GetMethod("Compare", typ18).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 153, 1, 153, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa19 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru19 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont19 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru19)
isSepIL.Emit(OpCodes.Br, fa19)
isSepIL.MarkLabel(tru19)
isSepIL.MarkSequencePoint(doc2, 154, 1, 154, 100)
Dim typ19(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ19(UBound(typ19) + 1)
typ19(UBound(typ19)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ19(UBound(typ19) + 1)
typ19(UBound(typ19)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ19))
Typ = GetType(String).GetMethod("Compare", typ19).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 155, 1, 155, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa20 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru20 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont20 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa20)
isSepIL.Emit(OpCodes.Br, tru20)
isSepIL.MarkLabel(tru20)
isSepIL.MarkSequencePoint(doc2, 156, 1, 156, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 157, 1, 157, 100)
Dim typ20(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ20(UBound(typ20) + 1)
typ20(UBound(typ20)) = Typ
isSepIL.Emit(OpCodes.Ldstr, ">")
Typ = GetType(System.String)
ReDim Preserve typ20(UBound(typ20) + 1)
typ20(UBound(typ20)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ20))
Typ = GetType(String).GetMethod("Compare", typ20).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 158, 1, 158, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa21 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru21 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont21 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru21)
isSepIL.Emit(OpCodes.Br, fa21)
isSepIL.MarkLabel(tru21)
isSepIL.MarkSequencePoint(doc2, 159, 1, 159, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 160, 1, 160, 100)
isSepIL.Emit(OpCodes.Br, cont21)
isSepIL.MarkLabel(fa21)
isSepIL.MarkSequencePoint(doc2, 161, 1, 161, 100)
Dim typ21(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ21(UBound(typ21) + 1)
typ21(UBound(typ21)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "<")
Typ = GetType(System.String)
ReDim Preserve typ21(UBound(typ21) + 1)
typ21(UBound(typ21)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ21))
Typ = GetType(String).GetMethod("Compare", typ21).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 162, 1, 162, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa22 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru22 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont22 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru22)
isSepIL.Emit(OpCodes.Br, fa22)
isSepIL.MarkLabel(tru22)
isSepIL.MarkSequencePoint(doc2, 163, 1, 163, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 164, 1, 164, 100)
isSepIL.Emit(OpCodes.Br, cont22)
isSepIL.MarkLabel(fa22)
isSepIL.MarkSequencePoint(doc2, 165, 1, 165, 100)
Dim typ22(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ22(UBound(typ22) + 1)
typ22(UBound(typ22)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "!")
Typ = GetType(System.String)
ReDim Preserve typ22(UBound(typ22) + 1)
typ22(UBound(typ22)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ22))
Typ = GetType(String).GetMethod("Compare", typ22).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 166, 1, 166, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa23 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru23 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont23 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru23)
isSepIL.Emit(OpCodes.Br, fa23)
isSepIL.MarkLabel(tru23)
isSepIL.MarkSequencePoint(doc2, 167, 1, 167, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 168, 1, 168, 100)
isSepIL.Emit(OpCodes.Br, cont23)
isSepIL.MarkLabel(fa23)
isSepIL.MarkSequencePoint(doc2, 169, 1, 169, 100)
Dim typ23(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ23(UBound(typ23) + 1)
typ23(UBound(typ23)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ23(UBound(typ23) + 1)
typ23(UBound(typ23)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ23))
Typ = GetType(String).GetMethod("Compare", typ23).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 170, 1, 170, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa24 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru24 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont24 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru24)
isSepIL.Emit(OpCodes.Br, fa24)
isSepIL.MarkLabel(tru24)
isSepIL.MarkSequencePoint(doc2, 171, 1, 171, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 172, 1, 172, 100)
isSepIL.Emit(OpCodes.Br, cont24)
isSepIL.MarkLabel(fa24)
isSepIL.MarkSequencePoint(doc2, 173, 1, 173, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 174, 1, 174, 100)
isSepIL.Emit(OpCodes.Br, cont24)
isSepIL.MarkLabel(cont24)
isSepIL.MarkSequencePoint(doc2, 175, 1, 175, 100)
isSepIL.Emit(OpCodes.Br, cont23)
isSepIL.MarkLabel(cont23)
isSepIL.MarkSequencePoint(doc2, 176, 1, 176, 100)
isSepIL.Emit(OpCodes.Br, cont22)
isSepIL.MarkLabel(cont22)
isSepIL.MarkSequencePoint(doc2, 177, 1, 177, 100)
isSepIL.Emit(OpCodes.Br, cont21)
isSepIL.MarkLabel(cont21)
isSepIL.MarkSequencePoint(doc2, 178, 1, 178, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 179, 1, 179, 100)
isSepIL.Emit(OpCodes.Br, cont20)
isSepIL.MarkLabel(fa20)
isSepIL.MarkSequencePoint(doc2, 180, 1, 180, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 181, 1, 181, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 182, 1, 182, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 183, 1, 183, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 184, 1, 184, 100)
isSepIL.Emit(OpCodes.Br, cont20)
isSepIL.MarkLabel(cont20)
isSepIL.MarkSequencePoint(doc2, 185, 1, 185, 100)
isSepIL.Emit(OpCodes.Br, cont19)
isSepIL.MarkLabel(fa19)
isSepIL.Emit(OpCodes.Br, cont19)
isSepIL.MarkLabel(cont19)
isSepIL.MarkSequencePoint(doc2, 187, 1, 187, 100)
Dim typ24(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ24(UBound(typ24) + 1)
typ24(UBound(typ24)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "!")
Typ = GetType(System.String)
ReDim Preserve typ24(UBound(typ24) + 1)
typ24(UBound(typ24)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ24))
Typ = GetType(String).GetMethod("Compare", typ24).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 189, 1, 189, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa25 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru25 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont25 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru25)
isSepIL.Emit(OpCodes.Br, fa25)
isSepIL.MarkLabel(tru25)
isSepIL.MarkSequencePoint(doc2, 190, 1, 190, 100)
Dim typ25(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ25(UBound(typ25) + 1)
typ25(UBound(typ25)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ25(UBound(typ25) + 1)
typ25(UBound(typ25)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ25))
Typ = GetType(String).GetMethod("Compare", typ25).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 191, 1, 191, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa26 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru26 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont26 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa26)
isSepIL.Emit(OpCodes.Br, tru26)
isSepIL.MarkLabel(tru26)
isSepIL.MarkSequencePoint(doc2, 192, 1, 192, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 193, 1, 193, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 194, 1, 194, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 195, 1, 195, 100)
isSepIL.Emit(OpCodes.Br, cont26)
isSepIL.MarkLabel(fa26)
isSepIL.MarkSequencePoint(doc2, 196, 1, 196, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 197, 1, 197, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 198, 1, 198, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 199, 1, 199, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 200, 1, 200, 100)
isSepIL.Emit(OpCodes.Br, cont26)
isSepIL.MarkLabel(cont26)
isSepIL.MarkSequencePoint(doc2, 201, 1, 201, 100)
isSepIL.Emit(OpCodes.Br, cont25)
isSepIL.MarkLabel(fa25)
isSepIL.Emit(OpCodes.Br, cont25)
isSepIL.MarkLabel(cont25)
isSepIL.MarkSequencePoint(doc2, 203, 1, 203, 100)
Dim typ26(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ26(UBound(typ26) + 1)
typ26(UBound(typ26)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "<")
Typ = GetType(System.String)
ReDim Preserve typ26(UBound(typ26) + 1)
typ26(UBound(typ26)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ26))
Typ = GetType(String).GetMethod("Compare", typ26).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 205, 1, 205, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa27 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru27 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont27 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru27)
isSepIL.Emit(OpCodes.Br, fa27)
isSepIL.MarkLabel(tru27)
isSepIL.MarkSequencePoint(doc2, 206, 1, 206, 100)
Dim typ27(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ27(UBound(typ27) + 1)
typ27(UBound(typ27)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ27(UBound(typ27) + 1)
typ27(UBound(typ27)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ27))
Typ = GetType(String).GetMethod("Compare", typ27).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 207, 1, 207, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa28 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru28 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont28 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru28)
isSepIL.Emit(OpCodes.Br, fa28)
isSepIL.MarkLabel(tru28)
isSepIL.MarkSequencePoint(doc2, 208, 1, 208, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 209, 1, 209, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 210, 1, 210, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 211, 1, 211, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 212, 1, 212, 100)
isSepIL.Emit(OpCodes.Br, cont28)
isSepIL.MarkLabel(fa28)
isSepIL.MarkSequencePoint(doc2, 213, 1, 213, 100)
Dim typ28(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ28(UBound(typ28) + 1)
typ28(UBound(typ28)) = Typ
isSepIL.Emit(OpCodes.Ldstr, ">")
Typ = GetType(System.String)
ReDim Preserve typ28(UBound(typ28) + 1)
typ28(UBound(typ28)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ28))
Typ = GetType(String).GetMethod("Compare", typ28).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 214, 1, 214, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa29 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru29 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont29 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru29)
isSepIL.Emit(OpCodes.Br, fa29)
isSepIL.MarkLabel(tru29)
isSepIL.MarkSequencePoint(doc2, 215, 1, 215, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 216, 1, 216, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 217, 1, 217, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 218, 1, 218, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 219, 1, 219, 100)
isSepIL.Emit(OpCodes.Br, cont29)
isSepIL.MarkLabel(fa29)
isSepIL.MarkSequencePoint(doc2, 220, 1, 220, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 221, 1, 221, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 222, 1, 222, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 223, 1, 223, 100)
isSepIL.Emit(OpCodes.Br, cont29)
isSepIL.MarkLabel(cont29)
isSepIL.MarkSequencePoint(doc2, 224, 1, 224, 100)
isSepIL.Emit(OpCodes.Br, cont28)
isSepIL.MarkLabel(cont28)
isSepIL.MarkSequencePoint(doc2, 225, 1, 225, 100)
isSepIL.Emit(OpCodes.Br, cont27)
isSepIL.MarkLabel(fa27)
isSepIL.Emit(OpCodes.Br, cont27)
isSepIL.MarkLabel(cont27)
isSepIL.MarkSequencePoint(doc2, 227, 1, 227, 100)
Dim typ29(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ29(UBound(typ29) + 1)
typ29(UBound(typ29)) = Typ
isSepIL.Emit(OpCodes.Ldstr, ">")
Typ = GetType(System.String)
ReDim Preserve typ29(UBound(typ29) + 1)
typ29(UBound(typ29)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ29))
Typ = GetType(String).GetMethod("Compare", typ29).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 229, 1, 229, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa30 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru30 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont30 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru30)
isSepIL.Emit(OpCodes.Br, fa30)
isSepIL.MarkLabel(tru30)
isSepIL.MarkSequencePoint(doc2, 230, 1, 230, 100)
Dim typ30(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ30(UBound(typ30) + 1)
typ30(UBound(typ30)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "=")
Typ = GetType(System.String)
ReDim Preserve typ30(UBound(typ30) + 1)
typ30(UBound(typ30)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ30))
Typ = GetType(String).GetMethod("Compare", typ30).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 231, 1, 231, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa31 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru31 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont31 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa31)
isSepIL.Emit(OpCodes.Br, tru31)
isSepIL.MarkLabel(tru31)
isSepIL.MarkSequencePoint(doc2, 232, 1, 232, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 233, 1, 233, 100)
Dim typ31(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ31(UBound(typ31) + 1)
typ31(UBound(typ31)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "<")
Typ = GetType(System.String)
ReDim Preserve typ31(UBound(typ31) + 1)
typ31(UBound(typ31)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ31))
Typ = GetType(String).GetMethod("Compare", typ31).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 234, 1, 234, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa32 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru32 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont32 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru32)
isSepIL.Emit(OpCodes.Br, fa32)
isSepIL.MarkLabel(tru32)
isSepIL.MarkSequencePoint(doc2, 235, 1, 235, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 236, 1, 236, 100)
isSepIL.Emit(OpCodes.Br, cont32)
isSepIL.MarkLabel(fa32)
isSepIL.MarkSequencePoint(doc2, 237, 1, 237, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 238, 1, 238, 100)
isSepIL.Emit(OpCodes.Br, cont32)
isSepIL.MarkLabel(cont32)
isSepIL.MarkSequencePoint(doc2, 239, 1, 239, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 240, 1, 240, 100)
isSepIL.Emit(OpCodes.Br, cont31)
isSepIL.MarkLabel(fa31)
isSepIL.MarkSequencePoint(doc2, 241, 1, 241, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 242, 1, 242, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 243, 1, 243, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 244, 1, 244, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 245, 1, 245, 100)
isSepIL.Emit(OpCodes.Br, cont31)
isSepIL.MarkLabel(cont31)
isSepIL.MarkSequencePoint(doc2, 246, 1, 246, 100)
isSepIL.Emit(OpCodes.Br, cont30)
isSepIL.MarkLabel(fa30)
isSepIL.Emit(OpCodes.Br, cont30)
isSepIL.MarkLabel(cont30)
isSepIL.MarkSequencePoint(doc2, 248, 1, 248, 100)
Dim typ32(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ32(UBound(typ32) + 1)
typ32(UBound(typ32)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "-")
Typ = GetType(System.String)
ReDim Preserve typ32(UBound(typ32) + 1)
typ32(UBound(typ32)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ32))
Typ = GetType(String).GetMethod("Compare", typ32).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 250, 1, 250, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa33 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru33 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont33 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru33)
isSepIL.Emit(OpCodes.Br, fa33)
isSepIL.MarkLabel(tru33)
isSepIL.MarkSequencePoint(doc2, 251, 1, 251, 100)
Dim typ33(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ33(UBound(typ33) + 1)
typ33(UBound(typ33)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "-")
Typ = GetType(System.String)
ReDim Preserve typ33(UBound(typ33) + 1)
typ33(UBound(typ33)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ33))
Typ = GetType(String).GetMethod("Compare", typ33).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 252, 1, 252, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa34 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru34 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont34 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa34)
isSepIL.Emit(OpCodes.Br, tru34)
isSepIL.MarkLabel(tru34)
isSepIL.MarkSequencePoint(doc2, 253, 1, 253, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 254, 1, 254, 100)
Dim typ34(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ34(UBound(typ34) + 1)
typ34(UBound(typ34)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "-")
Typ = GetType(System.String)
ReDim Preserve typ34(UBound(typ34) + 1)
typ34(UBound(typ34)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ34))
Typ = GetType(String).GetMethod("Compare", typ34).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 255, 1, 255, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa35 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru35 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont35 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru35)
isSepIL.Emit(OpCodes.Br, fa35)
isSepIL.MarkLabel(tru35)
isSepIL.MarkSequencePoint(doc2, 256, 1, 256, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 257, 1, 257, 100)
isSepIL.Emit(OpCodes.Br, cont35)
isSepIL.MarkLabel(fa35)
isSepIL.MarkSequencePoint(doc2, 258, 1, 258, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 259, 1, 259, 100)
isSepIL.Emit(OpCodes.Br, cont35)
isSepIL.MarkLabel(cont35)
isSepIL.MarkSequencePoint(doc2, 260, 1, 260, 100)
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
Dim typ35 As Type() = {Typ}
isSepIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToChar", typ35))
Typ = GetType(System.Convert).GetMethod("ToChar", typ35).ReturnType
isSepIL.Emit(OpCodes.Stloc, 3)
isSepIL.MarkSequencePoint(doc2, 261, 1, 261, 100)
Dim typ36(-1) As Type
isSepIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Char)
ReDim Preserve typ36(UBound(typ36) + 1)
typ36(UBound(typ36)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(Char).GetMethod("IsDigit", typ36))
Typ = GetType(Char).GetMethod("IsDigit", typ36).ReturnType
isSepIL.Emit(OpCodes.Stloc, 4)
isSepIL.MarkSequencePoint(doc2, 262, 1, 262, 100)
isSepIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa36 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru36 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont36 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru36)
isSepIL.Emit(OpCodes.Br, fa36)
isSepIL.MarkLabel(tru36)
isSepIL.MarkSequencePoint(doc2, 263, 1, 263, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 264, 1, 264, 100)
isSepIL.Emit(OpCodes.Br, cont36)
isSepIL.MarkLabel(fa36)
isSepIL.Emit(OpCodes.Br, cont36)
isSepIL.MarkLabel(cont36)
isSepIL.MarkSequencePoint(doc2, 265, 1, 265, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 266, 1, 266, 100)
isSepIL.Emit(OpCodes.Br, cont34)
isSepIL.MarkLabel(fa34)
isSepIL.MarkSequencePoint(doc2, 267, 1, 267, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 268, 1, 268, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 269, 1, 269, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 270, 1, 270, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 271, 1, 271, 100)
isSepIL.Emit(OpCodes.Br, cont34)
isSepIL.MarkLabel(cont34)
isSepIL.MarkSequencePoint(doc2, 272, 1, 272, 100)
isSepIL.Emit(OpCodes.Br, cont33)
isSepIL.MarkLabel(fa33)
isSepIL.Emit(OpCodes.Br, cont33)
isSepIL.MarkLabel(cont33)
isSepIL.MarkSequencePoint(doc2, 274, 1, 274, 100)
Dim typ37(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ37(UBound(typ37) + 1)
typ37(UBound(typ37)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "+")
Typ = GetType(System.String)
ReDim Preserve typ37(UBound(typ37) + 1)
typ37(UBound(typ37)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ37))
Typ = GetType(String).GetMethod("Compare", typ37).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 276, 1, 276, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa37 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru37 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont37 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru37)
isSepIL.Emit(OpCodes.Br, fa37)
isSepIL.MarkLabel(tru37)
isSepIL.MarkSequencePoint(doc2, 277, 1, 277, 100)
Dim typ38(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
ReDim Preserve typ38(UBound(typ38) + 1)
typ38(UBound(typ38)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "+")
Typ = GetType(System.String)
ReDim Preserve typ38(UBound(typ38) + 1)
typ38(UBound(typ38)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ38))
Typ = GetType(String).GetMethod("Compare", typ38).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 278, 1, 278, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa38 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru38 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont38 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, fa38)
isSepIL.Emit(OpCodes.Br, tru38)
isSepIL.MarkLabel(tru38)
isSepIL.MarkSequencePoint(doc2, 279, 1, 279, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 280, 1, 280, 100)
Dim typ39(-1) As Type
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldfld, PrevChar)
Typ = PrevChar.FieldType
ReDim Preserve typ39(UBound(typ39) + 1)
typ39(UBound(typ39)) = Typ
isSepIL.Emit(OpCodes.Ldstr, "+")
Typ = GetType(System.String)
ReDim Preserve typ39(UBound(typ39) + 1)
typ39(UBound(typ39)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ39))
Typ = GetType(String).GetMethod("Compare", typ39).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 281, 1, 281, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa39 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru39 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont39 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru39)
isSepIL.Emit(OpCodes.Br, fa39)
isSepIL.MarkLabel(tru39)
isSepIL.MarkSequencePoint(doc2, 282, 1, 282, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 283, 1, 283, 100)
isSepIL.Emit(OpCodes.Br, cont39)
isSepIL.MarkLabel(fa39)
isSepIL.MarkSequencePoint(doc2, 284, 1, 284, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 285, 1, 285, 100)
isSepIL.Emit(OpCodes.Br, cont39)
isSepIL.MarkLabel(cont39)
isSepIL.MarkSequencePoint(doc2, 286, 1, 286, 100)
isSepIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
Dim typ40 As Type() = {Typ}
isSepIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToChar", typ40))
Typ = GetType(System.Convert).GetMethod("ToChar", typ40).ReturnType
isSepIL.Emit(OpCodes.Stloc, 3)
isSepIL.MarkSequencePoint(doc2, 287, 1, 287, 100)
Dim typ41(-1) As Type
isSepIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Char)
ReDim Preserve typ41(UBound(typ41) + 1)
typ41(UBound(typ41)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(Char).GetMethod("IsDigit", typ41))
Typ = GetType(Char).GetMethod("IsDigit", typ41).ReturnType
isSepIL.Emit(OpCodes.Stloc, 4)
isSepIL.MarkSequencePoint(doc2, 288, 1, 288, 100)
isSepIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa40 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru40 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont40 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru40)
isSepIL.Emit(OpCodes.Br, fa40)
isSepIL.MarkLabel(tru40)
isSepIL.MarkSequencePoint(doc2, 289, 1, 289, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 290, 1, 290, 100)
isSepIL.Emit(OpCodes.Br, cont40)
isSepIL.MarkLabel(fa40)
isSepIL.Emit(OpCodes.Br, cont40)
isSepIL.MarkLabel(cont40)
isSepIL.MarkSequencePoint(doc2, 291, 1, 291, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 292, 1, 292, 100)
isSepIL.Emit(OpCodes.Br, cont38)
isSepIL.MarkLabel(fa38)
isSepIL.MarkSequencePoint(doc2, 293, 1, 293, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 294, 1, 294, 100)
isSepIL.Emit(OpCodes.Ldarg, 4)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 295, 1, 295, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 296, 1, 296, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 297, 1, 297, 100)
isSepIL.Emit(OpCodes.Br, cont38)
isSepIL.MarkLabel(cont38)
isSepIL.MarkSequencePoint(doc2, 298, 1, 298, 100)
isSepIL.Emit(OpCodes.Br, cont37)
isSepIL.MarkLabel(fa37)
isSepIL.Emit(OpCodes.Br, cont37)
isSepIL.MarkLabel(cont37)
isSepIL.MarkSequencePoint(doc2, 300, 1, 300, 100)
Dim typ42(-1) As Type
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ42(UBound(typ42) + 1)
typ42(UBound(typ42)) = Typ
isSepIL.Emit(OpCodes.Ldstr, " ")
Typ = GetType(System.String)
ReDim Preserve typ42(UBound(typ42) + 1)
typ42(UBound(typ42)) = Typ
isSepIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ42))
Typ = GetType(String).GetMethod("Compare", typ42).ReturnType
isSepIL.Emit(OpCodes.Stloc, 0)
isSepIL.MarkSequencePoint(doc2, 302, 1, 302, 100)
isSepIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.Int32)
isSepIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa41 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim tru41 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
Dim cont41 As System.Reflection.Emit.Label = isSepIL.DefineLabel()
isSepIL.Emit(OpCodes.Beq, tru41)
isSepIL.Emit(OpCodes.Br, fa41)
isSepIL.MarkLabel(tru41)
isSepIL.MarkSequencePoint(doc2, 303, 1, 303, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 304, 1, 304, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 305, 1, 305, 100)
isSepIL.Emit(OpCodes.Br, label0)
isSepIL.MarkSequencePoint(doc2, 306, 1, 306, 100)
isSepIL.Emit(OpCodes.Br, cont41)
isSepIL.MarkLabel(fa41)
isSepIL.MarkSequencePoint(doc2, 307, 1, 307, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 308, 1, 308, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 309, 1, 309, 100)
isSepIL.Emit(OpCodes.Br, cont41)
isSepIL.MarkLabel(cont41)
isSepIL.MarkSequencePoint(doc2, 311, 1, 311, 100)
isSepIL.Emit(OpCodes.Br, cont4)
isSepIL.MarkLabel(fa4)
isSepIL.MarkSequencePoint(doc2, 312, 1, 312, 100)
isSepIL.Emit(OpCodes.Ldarg, 3)
Typ = GetType(System.Boolean).MakeByRefType()
Typ04 = Typ.GetElementType()
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stobj, Typ04)
isSepIL.MarkSequencePoint(doc2, 313, 1, 313, 100)
isSepIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
isSepIL.Emit(OpCodes.Stloc, 2)
isSepIL.MarkSequencePoint(doc2, 314, 1, 314, 100)
isSepIL.Emit(OpCodes.Br, cont4)
isSepIL.MarkLabel(cont4)
isSepIL.MarkSequencePoint(doc2, 316, 1, 316, 100)
isSepIL.MarkLabel(label0)
isSepIL.MarkSequencePoint(doc2, 318, 1, 318, 100)
isSepIL.Emit(OpCodes.Ldarg_0)
isSepIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
isSepIL.Emit(OpCodes.Stfld, PrevChar)
isSepIL.MarkSequencePoint(doc2, 319, 1, 319, 100)
isSepIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(System.Boolean)
isSepIL.MarkSequencePoint(doc2, 321, 1, 321, 100)
isSepIL.Emit(OpCodes.Ret)
Dim typ43(-1) As Type
ReDim Preserve typ43(UBound(typ43) + 1)
typ43(UBound(typ43)) = GetType(Stmt)
ReDim Preserve typ43(UBound(typ43) + 1)
typ43(UBound(typ43)) = GetType(System.String)
Dim Analyze As MethodBuilder = Line.DefineMethod("Analyze", MethodAttributes.Public, GetType(Stmt), typ43)
Dim AnalyzeIL As ILGenerator = Analyze.GetILGenerator()
Dim Analyzeparam00 As ParameterBuilder = Analyze.DefineParameter(0, ParameterAttributes.RetVal, "")
Dim Analyzeparam01 As ParameterBuilder = Analyze.DefineParameter(1, ParameterAttributes.None, "stm")
Dim Analyzeparam02 As ParameterBuilder = Analyze.DefineParameter(2, ParameterAttributes.None, "str")
AnalyzeIL.MarkSequencePoint(doc2, 325, 1, 325, 100)
Dim locbldr5 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr5.SetLocalSymInfo("curchar")
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 0)
AnalyzeIL.MarkSequencePoint(doc2, 326, 1, 326, 100)
Dim locbldr6 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr6.SetLocalSymInfo("lachar")
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc2, 327, 1, 327, 100)
Dim locbldr7 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(Token))
locbldr7.SetLocalSymInfo("curtok")
AnalyzeIL.Emit(OpCodes.Ldnull)
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc2, 328, 1, 328, 100)
Dim locbldr8 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr8.SetLocalSymInfo("len")
AnalyzeIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("get_Length", Type.EmptyTypes))
Typ = Typ03.GetMethod("get_Length", Type.EmptyTypes).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 3)
AnalyzeIL.MarkSequencePoint(doc2, 329, 1, 329, 100)
Dim locbldr9 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr9.SetLocalSymInfo("comp")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc2, 330, 1, 330, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Sub)
AnalyzeIL.Emit(OpCodes.Stloc, 3)
AnalyzeIL.MarkSequencePoint(doc2, 332, 1, 332, 100)
Dim locbldr10 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr10.SetLocalSymInfo("buf")
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 333, 1, 333, 100)
Dim locbldr11 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr11.SetLocalSymInfo("cuttok")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 6)
AnalyzeIL.MarkSequencePoint(doc2, 334, 1, 334, 100)
Dim locbldr12 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr12.SetLocalSymInfo("sc")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 7)
AnalyzeIL.MarkSequencePoint(doc2, 335, 1, 335, 100)
Dim locbldr13 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr13.SetLocalSymInfo("scl")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 8)
AnalyzeIL.MarkSequencePoint(doc2, 336, 1, 336, 100)
Dim locbldr14 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr14.SetLocalSymInfo("i")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(-1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 9)
AnalyzeIL.MarkSequencePoint(doc2, 337, 1, 337, 100)
Dim locbldr15 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr15.SetLocalSymInfo("j")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 10)
AnalyzeIL.MarkSequencePoint(doc2, 338, 1, 338, 100)
Dim label1 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.MarkSequencePoint(doc2, 339, 1, 339, 100)
Dim label2 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.MarkSequencePoint(doc2, 341, 1, 341, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(-1))
Typ = GetType(System.Int32)
Dim fa42 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru42 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont42 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru42)
AnalyzeIL.Emit(OpCodes.Br, fa42)
AnalyzeIL.MarkLabel(tru42)
AnalyzeIL.MarkSequencePoint(doc2, 342, 1, 342, 100)
AnalyzeIL.Emit(OpCodes.Br, label2)
AnalyzeIL.MarkSequencePoint(doc2, 343, 1, 343, 100)
AnalyzeIL.Emit(OpCodes.Br, cont42)
AnalyzeIL.MarkLabel(fa42)
AnalyzeIL.Emit(OpCodes.Br, cont42)
AnalyzeIL.MarkLabel(cont42)
AnalyzeIL.MarkSequencePoint(doc2, 345, 1, 345, 100)
AnalyzeIL.MarkLabel(label1)
AnalyzeIL.MarkSequencePoint(doc2, 347, 1, 347, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Add)
AnalyzeIL.Emit(OpCodes.Stloc, 9)
AnalyzeIL.MarkSequencePoint(doc2, 348, 1, 348, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Add)
AnalyzeIL.Emit(OpCodes.Stloc, 10)
AnalyzeIL.MarkSequencePoint(doc2, 349, 1, 349, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 6)
AnalyzeIL.MarkSequencePoint(doc2, 351, 1, 351, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
Dim fa43 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru43 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont43 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru43)
AnalyzeIL.Emit(OpCodes.Br, fa43)
AnalyzeIL.MarkLabel(tru43)
AnalyzeIL.MarkSequencePoint(doc2, 352, 1, 352, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 7)
AnalyzeIL.MarkSequencePoint(doc2, 353, 1, 353, 100)
AnalyzeIL.Emit(OpCodes.Br, cont43)
AnalyzeIL.MarkLabel(fa43)
AnalyzeIL.Emit(OpCodes.Br, cont43)
AnalyzeIL.MarkLabel(cont43)
AnalyzeIL.MarkSequencePoint(doc2, 355, 1, 355, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 7)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa44 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru44 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont44 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru44)
AnalyzeIL.Emit(OpCodes.Br, fa44)
AnalyzeIL.MarkLabel(tru44)
AnalyzeIL.MarkSequencePoint(doc2, 356, 1, 356, 100)
Dim typ45(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
ReDim Preserve typ45(UBound(typ45) + 1)
typ45(UBound(typ45)) = Typ
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
ReDim Preserve typ45(UBound(typ45) + 1)
typ45(UBound(typ45)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ45))
Typ = GetType(String).GetMethod("Compare", typ45).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc2, 357, 1, 357, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa45 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru45 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont45 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, fa45)
AnalyzeIL.Emit(OpCodes.Br, tru45)
AnalyzeIL.MarkLabel(tru45)
AnalyzeIL.MarkSequencePoint(doc2, 358, 1, 358, 100)
AnalyzeIL.Emit(OpCodes.Newobj, GetType(Token).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc2, 359, 1, 359, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Value"))
AnalyzeIL.MarkSequencePoint(doc2, 360, 1, 360, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
AnalyzeIL.Emit(OpCodes.Ldfld, GetType(Stmt).GetField("Line"))
Typ = GetType(Stmt).GetField("Line").FieldType
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Line"))
AnalyzeIL.MarkSequencePoint(doc2, 361, 1, 361, 100)
Dim typ46(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
ReDim Preserve typ46(UBound(typ46) + 1)
typ46(UBound(typ46)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("AddToken", typ46))
Typ = Typ03.GetMethod("AddToken", typ46).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc2, 362, 1, 362, 100)
AnalyzeIL.Emit(OpCodes.Br, cont45)
AnalyzeIL.MarkLabel(fa45)
AnalyzeIL.Emit(OpCodes.Br, cont45)
AnalyzeIL.MarkLabel(cont45)
AnalyzeIL.MarkSequencePoint(doc2, 363, 1, 363, 100)
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 364, 1, 364, 100)
AnalyzeIL.Emit(OpCodes.Br, cont44)
AnalyzeIL.MarkLabel(fa44)
AnalyzeIL.Emit(OpCodes.Br, cont44)
AnalyzeIL.MarkLabel(cont44)
AnalyzeIL.MarkSequencePoint(doc2, 366, 1, 366, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 7)
AnalyzeIL.MarkSequencePoint(doc2, 367, 1, 367, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 8)
AnalyzeIL.MarkSequencePoint(doc2, 369, 1, 369, 100)
Dim typ47(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
ReDim Preserve typ47(UBound(typ47) + 1)
typ47(UBound(typ47)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("get_Chars", typ47))
Typ = Typ03.GetMethod("get_Chars", typ47).ReturnType
Dim typ48 As Type() = {Typ}
AnalyzeIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToString", typ48))
Typ = GetType(System.Convert).GetMethod("ToString", typ48).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 0)
AnalyzeIL.MarkSequencePoint(doc2, 371, 1, 371, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Int32)
Dim fa46 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru46 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont46 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Blt, tru46)
AnalyzeIL.Emit(OpCodes.Br, fa46)
AnalyzeIL.MarkLabel(tru46)
AnalyzeIL.MarkSequencePoint(doc2, 372, 1, 372, 100)
Dim typ49(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 2)
Typ = GetType(System.String)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 10)
Typ = GetType(System.Int32)
ReDim Preserve typ49(UBound(typ49) + 1)
typ49(UBound(typ49)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("get_Chars", typ49))
Typ = Typ03.GetMethod("get_Chars", typ49).ReturnType
Dim typ50 As Type() = {Typ}
AnalyzeIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToString", typ50))
Typ = GetType(System.Convert).GetMethod("ToString", typ50).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc2, 373, 1, 373, 100)
AnalyzeIL.Emit(OpCodes.Br, cont46)
AnalyzeIL.MarkLabel(fa46)
AnalyzeIL.MarkSequencePoint(doc2, 374, 1, 374, 100)
AnalyzeIL.Emit(OpCodes.Ldnull)
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc2, 375, 1, 375, 100)
AnalyzeIL.Emit(OpCodes.Br, cont46)
AnalyzeIL.MarkLabel(cont46)
AnalyzeIL.MarkSequencePoint(doc2, 377, 1, 377, 100)
AnalyzeIL.Emit(OpCodes.Ldarg_0)
Dim typ51(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.String)
ReDim Preserve typ51(UBound(typ51) + 1)
typ51(UBound(typ51)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(System.String)
ReDim Preserve typ51(UBound(typ51) + 1)
typ51(UBound(typ51)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloca, 7)
Typ = GetType(System.Boolean).MakeByRefType()
ReDim Preserve typ51(UBound(typ51) + 1)
typ51(UBound(typ51)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloca, 8)
Typ = GetType(System.Boolean).MakeByRefType()
ReDim Preserve typ51(UBound(typ51) + 1)
typ51(UBound(typ51)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, isSep)
Typ = isSep.ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 6)
AnalyzeIL.MarkSequencePoint(doc2, 379, 1, 379, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 6)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa47 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru47 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont47 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru47)
AnalyzeIL.Emit(OpCodes.Br, fa47)
AnalyzeIL.MarkLabel(tru47)
AnalyzeIL.MarkSequencePoint(doc2, 380, 1, 380, 100)
Dim typ52(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
ReDim Preserve typ52(UBound(typ52) + 1)
typ52(UBound(typ52)) = Typ
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
ReDim Preserve typ52(UBound(typ52) + 1)
typ52(UBound(typ52)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ52))
Typ = GetType(String).GetMethod("Compare", typ52).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc2, 381, 1, 381, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa48 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru48 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont48 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, fa48)
AnalyzeIL.Emit(OpCodes.Br, tru48)
AnalyzeIL.MarkLabel(tru48)
AnalyzeIL.MarkSequencePoint(doc2, 382, 1, 382, 100)
AnalyzeIL.Emit(OpCodes.Newobj, GetType(Token).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc2, 383, 1, 383, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Value"))
AnalyzeIL.MarkSequencePoint(doc2, 384, 1, 384, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
AnalyzeIL.Emit(OpCodes.Ldfld, GetType(Stmt).GetField("Line"))
Typ = GetType(Stmt).GetField("Line").FieldType
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Line"))
AnalyzeIL.MarkSequencePoint(doc2, 385, 1, 385, 100)
Dim typ53(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
ReDim Preserve typ53(UBound(typ53) + 1)
typ53(UBound(typ53)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("AddToken", typ53))
Typ = Typ03.GetMethod("AddToken", typ53).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc2, 386, 1, 386, 100)
AnalyzeIL.Emit(OpCodes.Br, cont48)
AnalyzeIL.MarkLabel(fa48)
AnalyzeIL.Emit(OpCodes.Br, cont48)
AnalyzeIL.MarkLabel(cont48)
AnalyzeIL.MarkSequencePoint(doc2, 387, 1, 387, 100)
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 388, 1, 388, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 7)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa49 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru49 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont49 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru49)
AnalyzeIL.Emit(OpCodes.Br, fa49)
AnalyzeIL.MarkLabel(tru49)
AnalyzeIL.MarkSequencePoint(doc2, 389, 1, 389, 100)
Dim typ54(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
ReDim Preserve typ54(UBound(typ54) + 1)
typ54(UBound(typ54)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.String)
ReDim Preserve typ54(UBound(typ54) + 1)
typ54(UBound(typ54)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Concat", typ54))
Typ = GetType(String).GetMethod("Concat", typ54).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 390, 1, 390, 100)
AnalyzeIL.Emit(OpCodes.Br, cont49)
AnalyzeIL.MarkLabel(fa49)
AnalyzeIL.Emit(OpCodes.Br, cont49)
AnalyzeIL.MarkLabel(cont49)
AnalyzeIL.MarkSequencePoint(doc2, 391, 1, 391, 100)
AnalyzeIL.Emit(OpCodes.Br, cont47)
AnalyzeIL.MarkLabel(fa47)
AnalyzeIL.MarkSequencePoint(doc2, 392, 1, 392, 100)
Dim typ55(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
ReDim Preserve typ55(UBound(typ55) + 1)
typ55(UBound(typ55)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(System.String)
ReDim Preserve typ55(UBound(typ55) + 1)
typ55(UBound(typ55)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Concat", typ55))
Typ = GetType(String).GetMethod("Concat", typ55).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 393, 1, 393, 100)
AnalyzeIL.Emit(OpCodes.Br, cont47)
AnalyzeIL.MarkLabel(cont47)
AnalyzeIL.MarkSequencePoint(doc2, 395, 1, 395, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.Int32)
Dim fa50 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru50 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont50 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru50)
AnalyzeIL.Emit(OpCodes.Br, fa50)
AnalyzeIL.MarkLabel(tru50)
AnalyzeIL.MarkSequencePoint(doc2, 396, 1, 396, 100)
AnalyzeIL.Emit(OpCodes.Br, label2)
AnalyzeIL.MarkSequencePoint(doc2, 397, 1, 397, 100)
AnalyzeIL.Emit(OpCodes.Br, cont50)
AnalyzeIL.MarkLabel(fa50)
AnalyzeIL.MarkSequencePoint(doc2, 398, 1, 398, 100)
AnalyzeIL.Emit(OpCodes.Br, label1)
AnalyzeIL.MarkSequencePoint(doc2, 399, 1, 399, 100)
AnalyzeIL.Emit(OpCodes.Br, cont50)
AnalyzeIL.MarkLabel(cont50)
AnalyzeIL.MarkSequencePoint(doc2, 401, 1, 401, 100)
AnalyzeIL.MarkLabel(label2)
AnalyzeIL.MarkSequencePoint(doc2, 403, 1, 403, 100)
Dim typ56(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
ReDim Preserve typ56(UBound(typ56) + 1)
typ56(UBound(typ56)) = Typ
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
ReDim Preserve typ56(UBound(typ56) + 1)
typ56(UBound(typ56)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ56))
Typ = GetType(String).GetMethod("Compare", typ56).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc2, 404, 1, 404, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa51 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru51 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont51 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, fa51)
AnalyzeIL.Emit(OpCodes.Br, tru51)
AnalyzeIL.MarkLabel(tru51)
AnalyzeIL.MarkSequencePoint(doc2, 405, 1, 405, 100)
AnalyzeIL.Emit(OpCodes.Newobj, GetType(Token).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc2, 406, 1, 406, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Value"))
AnalyzeIL.MarkSequencePoint(doc2, 407, 1, 407, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
AnalyzeIL.Emit(OpCodes.Ldfld, GetType(Stmt).GetField("Line"))
Typ = GetType(Stmt).GetField("Line").FieldType
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Token).GetField("Line"))
AnalyzeIL.MarkSequencePoint(doc2, 408, 1, 408, 100)
Dim typ57(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = GetType(Token)
ReDim Preserve typ57(UBound(typ57) + 1)
typ57(UBound(typ57)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("AddToken", typ57))
Typ = Typ03.GetMethod("AddToken", typ57).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc2, 409, 1, 409, 100)
AnalyzeIL.Emit(OpCodes.Br, cont51)
AnalyzeIL.MarkLabel(fa51)
AnalyzeIL.Emit(OpCodes.Br, cont51)
AnalyzeIL.MarkLabel(cont51)
AnalyzeIL.MarkSequencePoint(doc2, 410, 1, 410, 100)
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc2, 412, 1, 412, 100)
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(Stmt)
AnalyzeIL.MarkSequencePoint(doc2, 414, 1, 414, 100)
AnalyzeIL.Emit(OpCodes.Ret)
Line.CreateType()
End Sub


Dim doc3 As ISymbolDocumentWriter

Sub Lexer()
Dim Lexer As TypeBuilder = mdl.DefineType("tokenizer.Lexer" & "." & "Lexer", TypeAttributes.Public Or TypeAttributes.AutoLayout Or TypeAttributes.AnsiClass, GetType(System.Object))
Dim typ0(-1) As Type
ReDim Preserve typ0(UBound(typ0) + 1)
typ0(UBound(typ0)) = GetType(System.String)
Dim Analyze As MethodBuilder = Lexer.DefineMethod("Analyze", MethodAttributes.Public, GetType(StmtSet), typ0)
Dim AnalyzeIL As ILGenerator = Analyze.GetILGenerator()
Dim Analyzeparam00 As ParameterBuilder = Analyze.DefineParameter(0, ParameterAttributes.RetVal, "")
Dim Analyzeparam01 As ParameterBuilder = Analyze.DefineParameter(1, ParameterAttributes.None, "path")
AnalyzeIL.MarkSequencePoint(doc3, 5, 1, 5, 100)
Dim locbldr16 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(StmtSet))
locbldr16.SetLocalSymInfo("stmts")
AnalyzeIL.Emit(OpCodes.Newobj, GetType(StmtSet).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 0)
AnalyzeIL.MarkSequencePoint(doc3, 6, 1, 6, 100)
Dim locbldr17 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(Stmt))
locbldr17.SetLocalSymInfo("curstmt")
AnalyzeIL.Emit(OpCodes.Ldnull)
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc3, 7, 1, 7, 100)
Dim locbldr18 As LocalBuilder = AnalyzeIL.DeclareLocal(asm.GetType("tokenizer.Lexer.Line"))
locbldr18.SetLocalSymInfo("curln")
AnalyzeIL.Emit(OpCodes.Ldnull)
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc3, 8, 1, 8, 100)
Dim locbldr19 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr19.SetLocalSymInfo("fs")
Dim typ1(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldarg, 1)
Typ = GetType(System.String)
ReDim Preserve typ1(UBound(typ1) + 1)
typ1(UBound(typ1)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(FileIO.FileSystem).GetMethod("ReadAllText", typ1))
Typ = GetType(FileIO.FileSystem).GetMethod("ReadAllText", typ1).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 3)
AnalyzeIL.MarkSequencePoint(doc3, 9, 1, 9, 100)
Dim locbldr20 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr20.SetLocalSymInfo("crflag")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc3, 10, 1, 10, 100)
Dim locbldr21 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr21.SetLocalSymInfo("lfflag")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc3, 11, 1, 11, 100)
Dim locbldr22 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr22.SetLocalSymInfo("andflg")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 6)
AnalyzeIL.MarkSequencePoint(doc3, 12, 1, 12, 100)
Dim locbldr23 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Boolean))
locbldr23.SetLocalSymInfo("orflg")
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 7)
AnalyzeIL.MarkSequencePoint(doc3, 13, 1, 13, 100)
Dim locbldr24 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr24.SetLocalSymInfo("buf")
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 8)
AnalyzeIL.MarkSequencePoint(doc3, 14, 1, 14, 100)
Dim locbldr25 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr25.SetLocalSymInfo("curline")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 9)
AnalyzeIL.MarkSequencePoint(doc3, 16, 1, 16, 100)
Dim locbldr26 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr26.SetLocalSymInfo("len")
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.String)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("get_Length", Type.EmptyTypes))
Typ = Typ03.GetMethod("get_Length", Type.EmptyTypes).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 10)
AnalyzeIL.MarkSequencePoint(doc3, 17, 1, 17, 100)
Dim locbldr27 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr27.SetLocalSymInfo("i")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(-1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 11)
AnalyzeIL.MarkSequencePoint(doc3, 18, 1, 18, 100)
Dim locbldr28 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.String))
locbldr28.SetLocalSymInfo("ch")
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 12)
AnalyzeIL.MarkSequencePoint(doc3, 19, 1, 19, 100)
Dim locbldr29 As LocalBuilder = AnalyzeIL.DeclareLocal(GetType(System.Int32))
locbldr29.SetLocalSymInfo("comp")
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stloc, 13)
AnalyzeIL.MarkSequencePoint(doc3, 21, 1, 21, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 10)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Sub)
AnalyzeIL.Emit(OpCodes.Stloc, 10)
AnalyzeIL.MarkSequencePoint(doc3, 23, 1, 23, 100)
Dim label0 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.MarkSequencePoint(doc3, 24, 1, 24, 100)
Dim label1 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.MarkSequencePoint(doc3, 26, 1, 26, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 10)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa52 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru52 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont52 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Blt, tru52)
AnalyzeIL.Emit(OpCodes.Br, fa52)
AnalyzeIL.MarkLabel(tru52)
AnalyzeIL.MarkSequencePoint(doc3, 27, 1, 27, 100)
AnalyzeIL.Emit(OpCodes.Br, label1)
AnalyzeIL.MarkSequencePoint(doc3, 28, 1, 28, 100)
AnalyzeIL.Emit(OpCodes.Br, cont52)
AnalyzeIL.MarkLabel(fa52)
AnalyzeIL.Emit(OpCodes.Br, cont52)
AnalyzeIL.MarkLabel(cont52)
AnalyzeIL.MarkSequencePoint(doc3, 30, 1, 30, 100)
AnalyzeIL.MarkLabel(label0)
AnalyzeIL.MarkSequencePoint(doc3, 32, 1, 32, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 11)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Add)
AnalyzeIL.Emit(OpCodes.Stloc, 11)
AnalyzeIL.MarkSequencePoint(doc3, 34, 1, 34, 100)
Dim typ3(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 3)
Typ = GetType(System.String)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 11)
Typ = GetType(System.Int32)
ReDim Preserve typ3(UBound(typ3) + 1)
typ3(UBound(typ3)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("get_Chars", typ3))
Typ = Typ03.GetMethod("get_Chars", typ3).ReturnType
Dim typ4 As Type() = {Typ}
AnalyzeIL.Emit(OpCodes.Call, GetType(System.Convert).GetMethod("ToString", typ4))
Typ = GetType(System.Convert).GetMethod("ToString", typ4).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 12)
AnalyzeIL.MarkSequencePoint(doc3, 35, 1, 35, 100)
Dim typ5(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 12)
Typ = GetType(System.String)
ReDim Preserve typ5(UBound(typ5) + 1)
typ5(UBound(typ5)) = Typ
AnalyzeIL.Emit(OpCodes.Ldsfld, GetType(dnu.Constants).GetField("cr"))
Typ = GetType(dnu.Constants).GetField("cr").FieldType
ReDim Preserve typ5(UBound(typ5) + 1)
typ5(UBound(typ5)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ5))
Typ = GetType(String).GetMethod("Compare", typ5).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 13)
AnalyzeIL.MarkSequencePoint(doc3, 37, 1, 37, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 13)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa53 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru53 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont53 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru53)
AnalyzeIL.Emit(OpCodes.Br, fa53)
AnalyzeIL.MarkLabel(tru53)
AnalyzeIL.MarkSequencePoint(doc3, 38, 1, 38, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc3, 39, 1, 39, 100)
AnalyzeIL.Emit(OpCodes.Br, cont53)
AnalyzeIL.MarkLabel(fa53)
AnalyzeIL.Emit(OpCodes.Br, cont53)
AnalyzeIL.MarkLabel(cont53)
AnalyzeIL.MarkSequencePoint(doc3, 41, 1, 41, 100)
Dim typ6(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 12)
Typ = GetType(System.String)
ReDim Preserve typ6(UBound(typ6) + 1)
typ6(UBound(typ6)) = Typ
AnalyzeIL.Emit(OpCodes.Ldsfld, GetType(dnu.Constants).GetField("lf"))
Typ = GetType(dnu.Constants).GetField("lf").FieldType
ReDim Preserve typ6(UBound(typ6) + 1)
typ6(UBound(typ6)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Compare", typ6))
Typ = GetType(String).GetMethod("Compare", typ6).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 13)
AnalyzeIL.MarkSequencePoint(doc3, 43, 1, 43, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 13)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(0))
Typ = GetType(System.Int32)
Dim fa54 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru54 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont54 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru54)
AnalyzeIL.Emit(OpCodes.Br, fa54)
AnalyzeIL.MarkLabel(tru54)
AnalyzeIL.MarkSequencePoint(doc3, 44, 1, 44, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc3, 45, 1, 45, 100)
AnalyzeIL.Emit(OpCodes.Br, cont54)
AnalyzeIL.MarkLabel(fa54)
AnalyzeIL.Emit(OpCodes.Br, cont54)
AnalyzeIL.MarkLabel(cont54)
AnalyzeIL.MarkSequencePoint(doc3, 47, 1, 47, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.And)
AnalyzeIL.Emit(OpCodes.Stloc, 6)
AnalyzeIL.MarkSequencePoint(doc3, 48, 1, 48, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 4)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Or)
AnalyzeIL.Emit(OpCodes.Stloc, 7)
AnalyzeIL.MarkSequencePoint(doc3, 50, 1, 50, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 7)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
Dim fa55 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru55 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont55 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru55)
AnalyzeIL.Emit(OpCodes.Br, fa55)
AnalyzeIL.MarkLabel(tru55)
AnalyzeIL.MarkSequencePoint(doc3, 51, 1, 51, 100)
Dim typ7(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.String)
ReDim Preserve typ7(UBound(typ7) + 1)
typ7(UBound(typ7)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 12)
Typ = GetType(System.String)
ReDim Preserve typ7(UBound(typ7) + 1)
typ7(UBound(typ7)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(String).GetMethod("Concat", typ7))
Typ = GetType(String).GetMethod("Concat", typ7).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 8)
AnalyzeIL.MarkSequencePoint(doc3, 52, 1, 52, 100)
AnalyzeIL.Emit(OpCodes.Br, cont55)
AnalyzeIL.MarkLabel(fa55)
AnalyzeIL.MarkSequencePoint(doc3, 53, 1, 53, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 5)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 1)
Typ = GetType(System.Boolean)
Dim fa56 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru56 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont56 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru56)
AnalyzeIL.Emit(OpCodes.Br, fa56)
AnalyzeIL.MarkLabel(tru56)
AnalyzeIL.MarkSequencePoint(doc3, 54, 1, 54, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Add)
AnalyzeIL.Emit(OpCodes.Stloc, 9)
AnalyzeIL.MarkSequencePoint(doc3, 55, 1, 55, 100)
Dim typ8(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.String)
ReDim Preserve typ8(UBound(typ8) + 1)
typ8(UBound(typ8)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(Console).GetMethod("WriteLine", typ8))
Typ = GetType(Console).GetMethod("WriteLine", typ8).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc3, 56, 1, 56, 100)
AnalyzeIL.Emit(OpCodes.Newobj, GetType(Stmt).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc3, 57, 1, 57, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Stmt).GetField("Line"))
AnalyzeIL.MarkSequencePoint(doc3, 58, 1, 58, 100)
AnalyzeIL.Emit(OpCodes.Newobj, asm.GetType("tokenizer.Lexer.Line").GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc3, 59, 1, 59, 100)
Dim typ9(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = asm.GetType("tokenizer.Lexer.Line")
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
ReDim Preserve typ9(UBound(typ9) + 1)
typ9(UBound(typ9)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.String)
ReDim Preserve typ9(UBound(typ9) + 1)
typ9(UBound(typ9)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Analyze", typ9))
Typ = Typ03.GetMethod("Analyze", typ9).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc3, 60, 1, 60, 100)
Dim typ10(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(StmtSet)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
ReDim Preserve typ10(UBound(typ10) + 1)
typ10(UBound(typ10)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("AddStmt", typ10))
Typ = Typ03.GetMethod("AddStmt", typ10).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc3, 61, 1, 61, 100)
AnalyzeIL.Emit(OpCodes.Ldstr, "")
Typ = GetType(System.String)
AnalyzeIL.Emit(OpCodes.Stloc, 8)
AnalyzeIL.MarkSequencePoint(doc3, 62, 1, 62, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 4)
AnalyzeIL.MarkSequencePoint(doc3, 63, 1, 63, 100)
AnalyzeIL.Emit(OpCodes.Ldc_I4, 0)
Typ = GetType(System.Boolean)
AnalyzeIL.Emit(OpCodes.Stloc, 5)
AnalyzeIL.MarkSequencePoint(doc3, 64, 1, 64, 100)
AnalyzeIL.Emit(OpCodes.Br, cont56)
AnalyzeIL.MarkLabel(fa56)
AnalyzeIL.Emit(OpCodes.Br, cont56)
AnalyzeIL.MarkLabel(cont56)
AnalyzeIL.MarkSequencePoint(doc3, 65, 1, 65, 100)
AnalyzeIL.Emit(OpCodes.Br, cont55)
AnalyzeIL.MarkLabel(cont55)
AnalyzeIL.MarkSequencePoint(doc3, 67, 1, 67, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 11)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldloc, 10)
Typ = GetType(System.Int32)
Dim fa57 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim tru57 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
Dim cont57 As System.Reflection.Emit.Label = AnalyzeIL.DefineLabel()
AnalyzeIL.Emit(OpCodes.Beq, tru57)
AnalyzeIL.Emit(OpCodes.Br, fa57)
AnalyzeIL.MarkLabel(tru57)
AnalyzeIL.MarkSequencePoint(doc3, 68, 1, 68, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Ldc_I4, CInt(1))
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Add)
AnalyzeIL.Emit(OpCodes.Stloc, 9)
AnalyzeIL.MarkSequencePoint(doc3, 69, 1, 69, 100)
Dim typ11(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.String)
ReDim Preserve typ11(UBound(typ11) + 1)
typ11(UBound(typ11)) = Typ
AnalyzeIL.Emit(OpCodes.Call, GetType(Console).GetMethod("WriteLine", typ11))
Typ = GetType(Console).GetMethod("WriteLine", typ11).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc3, 70, 1, 70, 100)
AnalyzeIL.Emit(OpCodes.Newobj, GetType(Stmt).GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc3, 71, 1, 71, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
AnalyzeIL.Emit(OpCodes.Ldloc, 9)
Typ = GetType(System.Int32)
AnalyzeIL.Emit(OpCodes.Stfld, GetType(Stmt).GetField("Line"))
AnalyzeIL.MarkSequencePoint(doc3, 72, 1, 72, 100)
AnalyzeIL.Emit(OpCodes.Newobj, asm.GetType("tokenizer.Lexer.Line").GetConstructor(Type.EmptyTypes))
AnalyzeIL.Emit(OpCodes.Stloc, 2)
AnalyzeIL.MarkSequencePoint(doc3, 73, 1, 73, 100)
Dim typ12(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 2)
Typ = asm.GetType("tokenizer.Lexer.Line")
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
ReDim Preserve typ12(UBound(typ12) + 1)
typ12(UBound(typ12)) = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 8)
Typ = GetType(System.String)
ReDim Preserve typ12(UBound(typ12) + 1)
typ12(UBound(typ12)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("Analyze", typ12))
Typ = Typ03.GetMethod("Analyze", typ12).ReturnType
AnalyzeIL.Emit(OpCodes.Stloc, 1)
AnalyzeIL.MarkSequencePoint(doc3, 74, 1, 74, 100)
Dim typ13(-1) As Type
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(StmtSet)
Typ03 = Typ
AnalyzeIL.Emit(OpCodes.Ldloc, 1)
Typ = GetType(Stmt)
ReDim Preserve typ13(UBound(typ13) + 1)
typ13(UBound(typ13)) = Typ
AnalyzeIL.Emit(OpCodes.Callvirt, Typ03.GetMethod("AddStmt", typ13))
Typ = Typ03.GetMethod("AddStmt", typ13).ReturnType
If Typ.ToString() = GetType(System.Void).ToString() Then

Else
AnalyzeIL.Emit(OpCodes.Pop)
End If
AnalyzeIL.MarkSequencePoint(doc3, 75, 1, 75, 100)
AnalyzeIL.Emit(OpCodes.Br, label1)
AnalyzeIL.MarkSequencePoint(doc3, 76, 1, 76, 100)
AnalyzeIL.Emit(OpCodes.Br, cont57)
AnalyzeIL.MarkLabel(fa57)
AnalyzeIL.MarkSequencePoint(doc3, 77, 1, 77, 100)
AnalyzeIL.Emit(OpCodes.Br, label0)
AnalyzeIL.MarkSequencePoint(doc3, 78, 1, 78, 100)
AnalyzeIL.Emit(OpCodes.Br, cont57)
AnalyzeIL.MarkLabel(cont57)
AnalyzeIL.MarkSequencePoint(doc3, 80, 1, 80, 100)
AnalyzeIL.MarkLabel(label1)
AnalyzeIL.MarkSequencePoint(doc3, 82, 1, 82, 100)
AnalyzeIL.Emit(OpCodes.Ldloc, 0)
Typ = GetType(StmtSet)
AnalyzeIL.MarkSequencePoint(doc3, 83, 1, 83, 100)
AnalyzeIL.Emit(OpCodes.Ret)
Lexer.CreateType()
End Sub

Sub Main()

asmName = New AssemblyName("tokenizer.Lexer")
asmName.Version = New System.Version(11, 1, 2, 0)
asm  = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.Save, CStr("E:\Code\dylannet\compiler\"))
mdl = asm.DefineDynamicModule(asmName.Name & ".dll" , asmName.Name & ".dll", True)
resw = mdl.DefineResource("tokenizer.Lexer.resources" ,  "Description")
doc = mdl.DefineDocument("E:\Code\dylannet\compiler\tokenizer.Lexer.txt", Guid.Empty, Guid.Empty, Guid.Empty)
doc2 = mdl.DefineDocument("E:\Code\dylannet\compiler\line.txt", Guid.Empty, Guid.Empty, Guid.Empty)
doc3 = mdl.DefineDocument("E:\Code\dylannet\compiler\lexer.txt", Guid.Empty, Guid.Empty, Guid.Empty)
addstr("tokenizer.Lexer")
addasm(asm)
Dim daType As Type = GetType(DebuggableAttribute)
Dim daCtor As ConstructorInfo = daType.GetConstructor(New Type() { GetType(DebuggableAttribute.DebuggingModes) })
Dim daBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(daCtor, New Object() {DebuggableAttribute.DebuggingModes.DisableOptimizations Or _
DebuggableAttribute.DebuggingModes.Default })
asm.SetCustomAttribute(daBuilder)

Line()
Lexer()
Dim vaType As Type = GetType(AssemblyFileVersionAttribute)
Dim vaCtor As ConstructorInfo = vaType.GetConstructor(New Type() { GetType(String) })
Dim vaBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(vaCtor, New Object() {"11.1.2.0"})
asm.SetCustomAttribute(vaBuilder)

Dim paType As Type = GetType(AssemblyProductAttribute)
Dim paCtor As ConstructorInfo = paType.GetConstructor(New Type() { GetType(String) })
Dim paBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(paCtor, New Object() {"tokenizer.Lexer"})
asm.SetCustomAttribute(paBuilder)

Dim ataType As Type = GetType(AssemblyTitleAttribute)
Dim ataCtor As ConstructorInfo = ataType.GetConstructor(New Type() { GetType(String) })
Dim ataBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(ataCtor, New Object() {"tokenizer.Lexer"})
asm.SetCustomAttribute(ataBuilder)

Dim deaType As Type = GetType(AssemblyDescriptionAttribute)
Dim deaCtor As ConstructorInfo = deaType.GetConstructor(New Type() { GetType(String) })
Dim deaBuilder As CustomAttributeBuilder = New CustomAttributeBuilder(deaCtor, New Object() {"tokenizer.Lexer"})
asm.SetCustomAttribute(deaBuilder)


asm.DefineVersionInfoResource()
asm.Save(asmName.Name & ".dll")
End Sub


End Module